
#include "EEPROM.h"
#include "Gray_Sensor.h"
#include "PID.h"
#include "encoder.h"
#include "main.h"
#include "ti_msp_dl_config.h"
#include "servo.h"
#include "cam.h"
#include "yb_motor.h"
#include "Stepper_Motor.h"
#include "Relay.h"
#include "mission.h"
#define UART1_DMA_BUFFER_SIZE 11
uint8_t uart1_dma_buffer[UART1_DMA_BUFFER_SIZE];
uint8_t test = 0;
int main(void)
{

  SYSCFG_DL_init();
  delay_ms(10);
  EEPROM_Init();
  SYSCFG_DL_TIMER_0_init();
  SYSCFG_DL_TIMER_1_init();
  SysTick_Init();

  NVIC_EnableIRQ(UART_0_INST_INT_IRQN);
  NVIC_EnableIRQ(TIMER_0_INST_INT_IRQN);
  NVIC_EnableIRQ(TIMER_1_INST_INT_IRQN);
	NVIC_EnableIRQ(PWM_A_INST_INT_IRQN);
  NVIC_EnableIRQ(PWM_B_INST_INT_IRQN);
	

  // 使能定时器0的ZERO中断
  DL_TimerG_enableInterrupt(TIMER_0_INST, DL_TIMERG_INTERRUPT_ZERO_EVENT);
  DL_TimerG_enableInterrupt(TIMER_1_INST, DL_TIMERG_INTERRUPT_ZERO_EVENT);
	DL_TimerG_enableInterrupt(PWM_A_INST, DL_TIMERG_INTERRUPT_CC0_DN_EVENT);
  DL_TimerG_enableInterrupt(PWM_B_INST, DL_TIMERG_INTERRUPT_CC0_DN_EVENT);
  LCD_Init();
  // 启动定时器0的计数器，开始计数
  DL_TimerG_startCounter(TIMER_0_INST);
  NVIC_ClearPendingIRQ(TIMER_0_INST_INT_IRQN);
  DL_TimerG_startCounter(TIMER_1_INST);
  NVIC_ClearPendingIRQ(TIMER_1_INST_INT_IRQN);
  DL_TimerG_startCounter(PWM_A_INST);
  NVIC_ClearPendingIRQ(PWM_A_INST_INT_IRQN);
  DL_TimerG_startCounter(PWM_B_INST);
  NVIC_ClearPendingIRQ(PWM_B_INST_INT_IRQN);

  

  DL_DMA_setSrcAddr(DMA, DMA_CH0_CHAN_ID, (uint32_t)(&UART_1_INST->RXDATA));
  DL_DMA_setDestAddr(DMA, DMA_CH0_CHAN_ID, (   uint32_t)(&uart1_dma_buffer[0]));
  DL_DMA_setTransferSize(DMA, DMA_CH0_CHAN_ID, UART1_DMA_BUFFER_SIZE);
  DL_DMA_enableChannel(DMA, DMA_CH0_CHAN_ID);

  NVIC_EnableIRQ(UART_1_INST_INT_IRQN);

  //servo_init();
  StepperMotor_init(&stepper_motor_A);
  StepperMotor_init(&stepper_motor_B);
  //StepperMotor_init(&stepper_motor_B);
  //W25QXX_first_Init();
  key_init();
  WIT_Init();
  motor_init();
  Relay_off(); // 关闭继电器
  //Relay_on(); // 打开继电器

  // buzzer_on();
  while (1)
  {
	  
    
    scheduler_run();
    




  }
}

void UART_0_INST_IRQHandler(void)
{
  switch (DL_UART_getPendingInterrupt(UART_0_INST))
  {
  case DL_UART_IIDX_RX:
  {
    char c = DL_UART_Main_receiveData(UART_0_INST);
    if (c == '\n')
    { // 只对\n处理
      uart_rx_buf[uart_rx_idx] = 0;
      parse_uart_command((char *)uart_rx_buf, &PID_encoder_BSPD);
      uart_rx_idx = 0;
    }
    else if (c != '\r' && uart_rx_idx < UART_BUF_LEN - 1)
    {
      uart_rx_buf[uart_rx_idx++] = c;
    }
  }
  break;
  default:
    break;
  }
}

void TIMER_0_INST_IRQHandler(void)
{
  switch (DL_TimerG_getPendingInterrupt(TIMER_0_INST))
  {
  case DL_TIMERG_IIDX_ZERO:
    // Mission_test(); // 执行任务
    button_ticks(); // 5ms按键处理
    GW_proc();
    // uart0_printf("%d\n",get_tick());
    DL_TimerG_clearInterruptStatus(TIMER_0_INST,
                                   DL_TIMERG_INTERRUPT_ZERO_EVENT);
    break;

  default:
    break;
  }
}

void TIMER_1_INST_IRQHandler(void)
{
  switch (DL_TimerG_getPendingInterrupt(TIMER_1_INST))
  {
  case DL_TIMERG_IIDX_ZERO:
    Mission_E();
    mission3_proc(); // 10ms周期调用
    // uart0_printf("%d\n",get_tick());
    DL_TimerG_clearInterruptStatus(TIMER_1_INST,
                                   DL_TIMERG_INTERRUPT_ZERO_EVENT);
    break;

  default:
    break;
  }
}
// 函数：获取用户归一化数据
// 参数：sensor：传感器指针；result：结果指针
// 返回值：unsigned char：成功返回1，失败返回0
// 判断传感器是否正常

void UART_1_INST_IRQHandler(void)
{
  // uart0_printf("UART_1_INST_IRQHandler\n");
  DL_DMA_disableChannel(DMA, DMA_CH0_CHAN_ID);

  uint8_t rxSize = UART1_DMA_BUFFER_SIZE - DL_DMA_getTransferSize(DMA, DMA_CH0_CHAN_ID);

  if (!DL_UART_isRXFIFOEmpty(UART_1_INST) && rxSize < UART1_DMA_BUFFER_SIZE)
    uart1_dma_buffer[rxSize++] = DL_UART_receiveData(UART_1_INST);
  //  uart0_printf("rxSize = %d\n", rxSize);
  //  uart0_printf("Raw data:\n");
  //  for (uint8_t i = 0; i < rxSize; i++)
  //  {
  //    uart0_printf("%02X ", uart1_dma_buffer[i]);
  //  }
  //  uart0_printf("\n");

  // for (uint8_t i = 0; i <= rxSize - 11; i++)
  // {
  //   if (uart1_dma_buffer[i] == 0x55 && uart1_dma_buffer[i + 1] == 0x55)
  //   {
  //     uart0_printf("Valid packet received:\n");
  //     for (uint8_t j = 0; j < 11; j++)
  //     {
  //       uart0_printf("%02X ", uart1_dma_buffer[i + j]);
  //     }
  //     uart0_printf("\n");
  //     break;
  //   }
  // }
  cal_cam_receive_data(&uart1_dma_buffer[0]);
  // if (mission_num == 2 && Mission_Start_Flag) // 控制舵机云台使得趋向于x,y
  // {
  //   static uint8_t servo1_lock = 0;
  //   static uint8_t servo3_lock = 0;

  //   // Dx Servo1 越往左,角度越大 值减小         // Dy Servo3 越往下,角度越大 值减小
  //   if (is_findblob && abs(XY_Servo.x_delta) <= MID_DELTA && abs(XY_Servo.y_delta) <= MID_DELTA)
  //   {
  //     // 达到宽容度范围，上锁
  //     servo1_lock = 1;
  //     servo3_lock = 1;
  //     Mission_Start_Flag = 0;
  //     set_servo1_angle(XY_Servo.x_angle); // 设置舵机1角度
  //     set_servo3_angle(XY_Servo.y_angle); // 设置舵机3角度
  //   }
  //   else
  //   {
  //     // 只要有超出宽容度，解锁
  //     if (abs(XY_Servo.x_delta) > MID_DELTA)
  //       servo1_lock = 0;
  //     if (abs(XY_Servo.y_delta) > MID_DELTA)
  //       servo3_lock = 0;

  //     // x、y都超出宽容度
  //     if (is_findblob && abs(XY_Servo.x_delta) > MID_DELTA && abs(XY_Servo.y_delta) > MID_DELTA)
  //     {
  //       if (!servo1_lock)
  //       {
  //         float control_val_x = PID_Calc(&Servox_PID, 0, XY_Servo.x_delta, 0);
  //         XY_Servo.x_angle -= control_val_x * 0.1f; // 调整x轴角度
  //         set_servo1_angle(XY_Servo.x_angle);
  //       }
  //       if (!servo3_lock)
  //       {
  //         float control_val_y = PID_Calc(&Servoy_PID, 0, XY_Servo.y_delta, 0);
  //         XY_Servo.y_angle += control_val_y * 0.1f; // 调整y轴角度
  //         set_servo3_angle(XY_Servo.y_angle);
  //       }
  //     }
  //     // 只y超出
  //     else if (is_findblob && abs(XY_Servo.x_delta) <= MID_DELTA && abs(XY_Servo.y_delta) > MID_DELTA)
  //     {
  //       servo1_lock = 1; // x已达标，上锁
  //       if (!servo3_lock)
  //       {
  //         float control_val_y = PID_Calc(&Servoy_PID, 0, XY_Servo.y_delta, 0);
  //         XY_Servo.y_angle += control_val_y * 0.1f;
  //         set_servo3_angle(XY_Servo.y_angle);
  //       }
  //     }
  //     // 只x超出
  //     else if (is_findblob && abs(XY_Servo.x_delta) > MID_DELTA && abs(XY_Servo.y_delta) <= MID_DELTA)
  //     {
  //       servo3_lock = 1; // y已达标，上锁
  //       if (!servo1_lock)
  //       {
  //         float control_val_x = PID_Calc(&Servox_PID, 0, XY_Servo.x_delta, 0);
  //         XY_Servo.x_angle -= control_val_x * 0.1f;
  //         set_servo1_angle(XY_Servo.x_angle);
  //       }
  //     }
  //   }
  // }
  // （可选）清1字节
  uint8_t dummy;
  DL_UART_drainRXFIFO(UART_1_INST, &dummy, 1);

  DL_DMA_setDestAddr(DMA, DMA_CH0_CHAN_ID, (uint32_t)&uart1_dma_buffer[0]);
  DL_DMA_setTransferSize(DMA, DMA_CH0_CHAN_ID, UART1_DMA_BUFFER_SIZE);
  DL_DMA_enableChannel(DMA, DMA_CH0_CHAN_ID);
}

// void DMA_IRQHandler(void)
//{
//   uart0_printf("DMA\n");
//     // 检查DMA通道0传输完成中断
//     if (DL_DMA_getRawInterruptStatus(DMA, DL_DMA_INTERRUPT_CHANNEL0))
//     {
//         // 清除中断标志
//         DL_DMA_clearInterruptStatus(DMA, DL_DMA_INTERRUPT_CHANNEL0);
//
//         // 调用传输完成回调
//         cal_cam_receive_data(Cam_DMA_Buffer);
//         // 重新配置DMA传输
//         DL_DMA_setSrcAddr(DMA, DMA_CH0_CHAN_ID, (uint32_t)(&UART_1_INST->RXDATA));
//         DL_DMA_setDestAddr(DMA, DMA_CH0_CHAN_ID, (uint32_t)(&Cam_DMA_Buffer[0]));
//         DL_DMA_setTransferSize(DMA, DMA_CH0_CHAN_ID, 11);
//         DL_DMA_enableChannel(DMA, DMA_CH0_CHAN_ID);
//         uart0_printf("DMA\n");
//     }
//
// }

// void UART_1_INST_IRQHandler(void) {
//   switch (DL_UART_getPendingInterrupt(UART_1_INST)) {
//   case DL_UART_IIDX_RX: {
//     uart0_printf("UART_1_INST_IRQHandler\n");

//   } break;
//   default:
//     break;
//   }
// }





void PWM_A_INST_IRQHandler(void)
{
	    // 判断是不是CC0比较匹配中断（即上升沿事件）
    if (DL_TimerG_getPendingInterrupt(PWM_A_INST) == DL_TIMERG_IIDX_CC0_DN)
    {

      //uart0_printf("PWM_A_INST_IRQHandler\n");
      if (stepper_motor_A.direction == STEPPER_FRONT)
      {
        StepperCnt_buff[0]++; // 步进电机A“计步”
      }
      else if (stepper_motor_A.direction == STEPPER_BACK)
      {
        StepperCnt_buff[0]--; // 步进电机A“计步”
      }
		  DL_Timer_clearInterruptStatus(PWM_A_INST, DL_TIMERG_INTERRUPT_CC0_DN_EVENT);

    }
	
}


void PWM_B_INST_IRQHandler(void)
{
    // 判断是不是CC0比较匹配中断（即上升沿事件）
    if (DL_TimerG_getPendingInterrupt(PWM_B_INST) == DL_TIMERG_IIDX_CC0_DN)
    {
      //uart0_printf("PWM_B_INST_IRQHandler\n");
      if (stepper_motor_B.direction == STEPPER_FRONT)
      {
        StepperCnt_buff[1]++; // 步进电机B“计步”
      }
      else if (stepper_motor_B.direction == STEPPER_BACK)
      {
        StepperCnt_buff[1]--; // 步进电机B“计步”
      }
      
      
      DL_Timer_clearInterruptStatus(PWM_B_INST, DL_TIMERG_INTERRUPT_CC0_DN_EVENT);
    }
}